 

\section{Comandos básicos MINIX/UNIX}


\subsection{passwd}

\noindent
\textbf{Póngale password root a root}

Utilizamos el comando:\textit{ \# passwd}

\subsection{pwd}

\noindent
\textbf{Indique qué directorio pasa a ser su ``current directory'' si ejecuta:}

\begin{enumerate}
\item \# cd /usr/src \\
Para saber cual es mi ``current directory'' utilizamos el comando : \textit{\# pwd }, lo que devolvió \textit{ /usr/src/ }
\item \# cd \\
Utilizamos el comando: \# pwd, lo que devolvió \textit{/}.
\item ?`Cómo explica el punto anterior? \\
Cuando cd no recibe parametros tienen como predeterminado \textit{/},que es el directorio raíz.
\end{enumerate}

\subsection{cat}

\noindent
\textbf{?`Cuál es el contenido del archivo /usr/src/.profile y para qué sirve?} 

Utilizamos el comando: \# cat /usr/src/.profile. Se puede ver el resultado en la figura. \ref{fig:profile}

	\begin{figure}[p!hbt]
		\centering
		\includegraphics[width=.5\textwidth]{img/profile.png}
		\caption{ /usr/src/.profile}
		\label{fig:profile}
	\end{figure}

El archivo  \textbf{/usr/src/.profile} permite al usuario configurar el entorno de su cuenta automáticamente cuando entra en el sistema.

\subsection{find}

\noindent
\textbf{?`En qué directorio se encuentra el archivo \emph{proc.c}?}

El comando sirve para encontrar la ubicación de archivos dentro del filesystem. El primer parametro indica a partir de que directorio debe buscar, y el -name nombre de archivo indica el nombre del archivo a encontrar.

Utilizamos el comando: \textit{\# find / -name proc.c }

Se encuentra en \textit{/usr/src/kernel/}

\subsection{mkdir}

\noindent
\textbf{Genere un directorio /usr/$<$nombregrupo$>$}

El comando \textsl{mkdir} se utiliza para crear un directorio, recibiendo el nombre del mismo como parámetro. Utilizamos el comando: \#  \textit{mkdir /usr/honoriox}

\subsection{cp}

\noindent
\textbf{Copie el archivo /etc/passwd al directorio /usr/$<$nombregrupo$>$}

Utilizamos el comando: \#  \textit{cp /etc/passwd /usr/honoriox}

\subsection{chgrp}

\noindent
\textbf{Cambie el grupo del archivo /usr/$<$nombregrupo$>$/passwd para que sea other}

Utilizamos el comando: \#  \textit{chgrp other /usr/honoriox/passwd}

\subsection{chown}

\noindent
\textbf{Cambie el propietario del archivo /usr/$<$nombregrupo$>$/passwd para que sea ast}

Utilizamos el comando: \#  \textit{chown ast /usr/honoriox/passwd}

\subsection{chmod}

\noindent
\textbf{Cambie los permisos del archivo /usr/$<$grupo$>$/passwd para que:}
\begin{itemize}
\item \textbf{el propietario tenga permisos de lectura, escritura y ejecución}
\item \textbf{el grupo tenga solo permisos de lectura y ejecución}
\item \textbf{el resto tenga solo permisos de ejecución}
\end{itemize}

El comando \textbf{chmod} establece los permisos de lectura, escritura y ejecución del archivo especificado.
Estos permisos se pasan de la siguiente manera: Se especifican cuatro dígitos octales (0-7). Cada permiso
tiene un valor y los dígitos son la suma. El segundo dígito selecciona los permisos para el usuario dueño
del archivo: lectura , escritura , y ejecución; el tercero establece los permisos para los otros
usuarios dentro del grupo del archivo, con los mismos valores; y por último, el cuarto dígito marca los
permisos para otros usuarios que no pertenecen al grupo.

Utilizamos el comando: \#  \textit{chmod 751 /usr/honoriox/passwd}

Como resumen de los ítem anteriores algunas capturas, se pueden ver en la Fig.: \ref{fig:cp_chgrp_chown_chmod} y Fig.:\ref{fig:aa}

	\begin{figure}[p!hbt]
		\centering
		\includegraphics[width=0.8\textwidth]{img/3-a.png}
		\caption{ cp chgrp chown chmod }
		\label{fig:cp_chgrp_chown_chmod}
	\end{figure}
	
	\begin{figure}[p!hbt]
		\centering
		\includegraphics[width=0.8\textwidth]{img/3-b.png}
		\caption{ man chmod }
		\label{fig:aa}
	\end{figure}


\subsection{grep}

\begin{itemize}
\item \textbf{Muestre las lineas que tienen el texto \emph{include} en el archivo /usr/src/kernel/main.c}\\

	\begin{figure}[p!hbt]
	\centering
	\includegraphics[width=0.4\textwidth]{img/grep.png}
	\caption{ Lineas que contienen la palabra include en  /usr/src/kernel/main.c}
	\label{fig:grep}
	\end{figure}

Utilizamos el comando: \#  \textit{grep include /usr/src/kernel/main.c}

\item \textbf{Muestre las lineas que tienen el texto \emph{POSIX} que se encuentren en todos los archivos de /usr/src/kernel/}\\
Utilizamos el comando: \#  grep POSIX /usr/src/kernel/*

	\begin{figure}[p!hbt]
		\centering
		\includegraphics[width=0.8\textwidth]{img/POSIX.png}
		\caption{ Lineas que contienen el texto \emph{POSIX} en  /usr/src/kernel/*}
		\label{fig:POSIX}
	\end{figure}

\end{itemize}

\subsection{su}

\begin{enumerate}
\item \textbf{?`Para qué sirve?}\\
Sirve para poder ejecutar comandos como si se estuviera logueado con otro usuario, con sus permisos y sus configuraciones. Si no se le pasan parámetros asume que se quiere emular al usuario \textbf{root}.
\item \textbf{?`Qué pasa si ejecuta \emph{su} estando logueado como root?}\\
Nada, dado que ya se está ejecutando las acciones como \textbf{root}.
\item \textbf{Genere una cuenta de $<$usuario$>$}\\
Utilizamos el comando: \#  adduser moski other /usr/moski
\item \textbf{Entre a la cuenta $<$usuario$>$ generada}\\
Utilizamos el comando: \#  su moski
\end{enumerate}

\subsection{passwd}
\begin{enumerate}
\item \textbf{Cambie la password del usuario \emph{nobody}}\\
Utilizamos el comando: \#  \textit{passwd nobody}
\item \textbf{Ejecutar el comando \emph{su} ?`Qué le solicita? ?`Sucede lo mismo que desde root? ?`Por qué?}\\

\$ \textit{su}\\
Password:\\

Solicita la password para corroborar que conocemos la password del usuario \textbf{root} y no darle permisos de \textbf{root} a un usuario que no conoce dicha contraseña. Desde el usuario \textbf{root} podemos volvernos cualquier usuario.
\end{enumerate}

\subsection{rm}

\noindent
\textbf{ Suprima el archivo /usr/$<$grupo$>$/passwd}

Utilizamos el comando: \# \textit{rm /usr/honoriox/passwd}

\subsection{ln}

\noindent
\textbf{Enlazar el archivo /etc/passwd a los siguientes archivos /tmp/contra1 y /tmp/contra2. Hacer un ls -l para ver cuantos enlaces tiene /etc/passwd}
\begin{itemize}
 \item Utilizamos el comando: \# \textit{ln /etc/passwd /tmp/contra1} 
 \item Utilizamos el comando: \# \textit{ln /etc/passwd /tmp/contra2} 
 \item Utilizamos el comando: \# \textit{ls -l /etc/passwd} 
\end{itemize}



\subsection{mkfs}
\begin{enumerate}
 \item 	  \textbf{Genere un Filesystem MINIX en un diskette}
\end{enumerate}
Utilizamos el comando: \# \textit{mkfs /dev/fd0}

\subsection{mount}
	\begin{enumerate}
	 \item\textbf{Montelo en el directorio \textbf{/mnt}}
	Utilizamos el comando: \# \textit{mount /dev/fd0 /mnt }
	 \item \textbf{Presente los filesystems que tiene montados}
	Utilizamos el comando: \# \textit{mount} el cual nos muestra los dispositivos montados
	\end{enumerate}

\subsection{df}

\begin{enumerate}
 \item \textbf{Que espacio libre y ocupado tienen todos los filesystems montados? (En KBYTES)}
\end{enumerate}
	
	\begin{figure}[p!hbt]
		\centering
		\includegraphics[width=1\textwidth]{img/mount_df.png}
		\caption{ Espacio libre y ocupado de los filesystems montados en bloques}
		\label{fig:Mount}
	\end{figure}

Para obtener el tamaño en KBYTES y dado que cada bloque son 1024 BYTES osea 1 KBYTES, la conversión es inmediata.
( 1 BLOQUE = 1 KBYTE )
\\

\subsection{ps}
		
\begin{enumerate}
 \item \textbf{Cuantos procesos de usuario tiene ejecutando ?} \\
Ejecutamos: \\
 
\#  \textit{ps} \\

Son 2, \textbf{sh} y \textbf{ps}
para obtener más detalles ejecutamos: \\

\# \textit{ps -alx}

Se pude apreciar el resultado en la figura: \ref{fig:mount1}.

	\begin{figure}[p!hbt]
		\centering
		\includegraphics[width=0.8\textwidth]{img/ps-lx1.png}
		\caption{ ps -lx }
		\label{fig:mount1}
	\end{figure}



\item \textbf{Indique cuantos son del sistema}

En total son 19, menos 2 de usuario tenemos 17 de sistema.

\end{enumerate}

\subsection{umount}
\begin{enumerate}
 \item \textbf{ Desmonte el Filesystem del directorio \textbf{ /mnt }}

	Utilizamos el comando: \# \textit{umount /dev/fd0 }

 \item \textbf{ monte el Filesystem del directorio \textbf{ /mnt }}

	Utilizamos el comando: \# \textit{mount /dev/fd0 /mnt} 

\item \textbf{ Desmonte el Filesystem del directorio \textbf{ /mnt }}

	Utilizamos el comando: \# \textit{umount /dev/fd0 }


\end{enumerate}
 

\subsection{fsck}

\noindent
\textbf{Chequee la consistencia de Filesystem del diskette }

Utilizamos el comando: \# \textit{fsck /dev/fd0 }

Se pude apreciar el resultado en la Fig.: \ref{fig:fsck}.

	\begin{figure}[p!hbt]
		\centering
		\includegraphics[width=0.75\textwidth]{img/fsck.png}
		\caption{ fsck /dev/fd0 }
		\label{fig:fsck}
	\end{figure}



\subsection{dosdir}

\noindent\textbf{Tome un diskette formateado en DOS con archivos y ejecute \textit{dosdir a}} \\
\textbf{Ejecute los comandos necesarios para que funcione correctamente el comando
anterior
}
 
Al ejecutar \textit{\# dosdir}, el comando nos pide la sintaxis correcta.
Luego intentamos montar el diskette, pero minix no reconoce el dosfilesystem. 
Luego decidimos pedir un \textit{\# dosdir /dev/fd0} directamente sobre el dispositivo, 
lo que funcionó. Luego intentamos  \textit{\# dosdir a} lo cual se traducía a  \textit{\# dosdir /dev/dosA}
para luego arrojar un error de que no puede abrir el dispositivo solicitado. Finalmente notamos que 
haciendo un link  \textit{\# ln /dev/fd0 /dev/dosA } el comando  \textit{\# dosdir a} funcionaba de acuerdo
a lo esperado / pedido.


\subsection{dosread}

\noindent
\textbf{Copie un archivo de texto desde un diskette DOS
al directorio /tmp}

Ejecutamos \textit{\# dosread -a A TEST.TXT $>$ /tmp/TEST.TXT} Obtuvimos lo esperado. El archivo del diskete fue copiado a la carpeta /tmp

\subsection{doswrite}

\noindent
\textbf{Copie el archivo /etc/passwd al diskette DOS}

Ejecutamos: \textit{\#} doswrite A passwd $<$ /etc/passwd. 
Obteniendo lo esperado.


\newpage
